{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 电商多轮对话机器人\n",
    "\n",
    "- 数据集：18年公开的淘宝客服对话数据 https://github.com/cooelf/DeepUtteranceAggregation\n",
    "- 实现类别：生成式模型\n",
    "- 模型架构：Seq2Seq模型，编码器使用多层双向GRU,解码器使用多层单向GRU及全局注意力机制，训练模式使用了teacher forcing和梯度修剪技巧，测试模式则使用集束搜索技巧来生成回答\n",
    "- 依赖：\n",
    "\n",
    "    - torch 1.0.1\n",
    "    - jieba 0.38\n",
    "    - numpy 1.15.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基本准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:15.558380Z",
     "start_time": "2019-03-31T12:22:12.541323Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import sys\n",
    "from collections import Counter\n",
    "import numpy as np\n",
    "import re\n",
    "import torch\n",
    "from torch import optim\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.nn.utils.rnn import pad_sequence, pack_padded_sequence, pad_packed_sequence\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import jieba\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:16.692349Z",
     "start_time": "2019-03-31T12:22:15.560409Z"
    }
   },
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda:0')\n",
    "    torch.cuda.init()\n",
    "else:\n",
    "    device = torch.device('cup')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载和处理数据\n",
    "\n",
    "- 目的：\n",
    "\n",
    "    将原始语料中的正确回答的对话段取出，将其处理成 上下文 + '\\t' + 回答的格式（多轮对话）的格式，同时统计各词汇的频数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 查看数据集基本信息\n",
    "\n",
    "- 原始数据格式\n",
    "\n",
    "    train.txt:原始对话语料训练集。每一行为 0/1(回答正确与否) + '\\t' + 问题1 + '\\t' + 回答1 + '\\t' + 问题2 + '\\t' + 回答2 + '\\t' ...**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:16.697363Z",
     "start_time": "2019-03-31T12:22:16.693346Z"
    }
   },
   "outputs": [],
   "source": [
    "# 查看文件的前几行\n",
    "def readline(datafile_dir):\n",
    "    with open(datafile_dir, 'r', encoding='utf-8') as f:\n",
    "        lines = f.readlines()\n",
    "        print(\"文件共有%s行\"%len(lines))\n",
    "        print(\"其中前四行为：\")\n",
    "        for line in lines[:4]:\n",
    "            print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:18.545434Z",
     "start_time": "2019-03-31T12:22:16.700327Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "文件共有1000000行\n",
      "其中前四行为：\n",
      "1\t538405926243 买 二份 有没有 少点 呀\t亲亲 真的 不好意思 我们 已经 是 优惠价 了 呢 小本生意 请亲 谅解\n",
      "\n",
      "0\t538405926243 买 二份 有没有 少点 呀\t恩恩 客官 现在 有个 活动 参加 就 有 礼 哦\n",
      "\n",
      "1\t我 一不小心 就 拍 了 一组 我 在 拍 一组 可以 嘛\t要 不亲 退 了 一起 拍 吧\t那 就 等 你们 处理 喽\t好 的 亲退 了\n",
      "\n",
      "0\t我 一不小心 就 拍 了 一组 我 在 拍 一组 可以 嘛\t要 不亲 退 了 一起 拍 吧\t那 就 等 你们 处理 喽\t亲亲 您 的 订单 今天 五箱 都 会 发货 的 您 看 今天 一起 给 您 发出 可以 吗\n",
      "\n"
     ]
    }
   ],
   "source": [
    "readline('data/train.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 处理和选择数据\n",
    "\n",
    "- 处理和选择后:\n",
    "\n",
    "    multi_train.txt:标准格式的多轮对话语料训练集，只取正确回答的行。每一行为 问题1 + <eos> + 问题2 + <eos> ... + '\\t' + 最后一个回答\n",
    "\n",
    "    vocab.txt:词汇频数字典。\n",
    "\n",
    "主要步骤：\n",
    "\n",
    "- 读取数据集，选择其中标签为1的对话\n",
    "- 将对话中的所有问题作为上下文，问题之间用<eos\\>相隔，将最后一个回答作为目标回答，问题和回答之间用\\t相隔,同时统计个单词的频数\n",
    "- 保存处理和选择过的数据集以及词汇频数字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:18.554367Z",
     "start_time": "2019-03-31T12:22:18.548383Z"
    }
   },
   "outputs": [],
   "source": [
    "def preprocess(raw_data_dir, save_dir):\n",
    "    # 统计数据集中单词频数\n",
    "    word_count = Counter()\n",
    "    \n",
    "    with open(raw_data_dir, 'r', encoding='utf-8') as f, open(save_dir, 'w', encoding='utf-8') as f1:\n",
    "        for line in f:\n",
    "            items = line.strip().split('\\t') # [标签,问题1,回答1,...]\n",
    "            if items[0] == '1':              # 只选取其中标记为1的行\n",
    "                # 更新词汇频数\n",
    "                words = line.split()[1:]     # 去掉每行开头的标记\n",
    "                word_count.update(words)     # 向word_count中加入文字，其会自动累计计数\n",
    "                \n",
    "                # 生成标准格式的多轮对话数据集\n",
    "                context = items[1:-1][::2]   # 将所有问题作为上下文\n",
    "                response = items[-1]\n",
    "                f1.write(' <eos> '.join(context) + '\\t' + response + '\\n') # 多个问题之间用 <eos> 隔开\n",
    "    # 存储频数字典\n",
    "    torch.save(word_count, 'vocab.txt')\n",
    "    \n",
    "    print(\"处理完成，已生成相应文件\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:28.950549Z",
     "start_time": "2019-03-31T12:22:18.555364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "处理完成，已生成相应文件\n"
     ]
    }
   ],
   "source": [
    "preprocess('data/train.txt', 'data/multi_train.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.709516Z",
     "start_time": "2019-03-31T12:22:28.952507Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "文件共有500000行\n",
      "其中前四行为：\n",
      "538405926243 买 二份 有没有 少点 呀\t亲亲 真的 不好意思 我们 已经 是 优惠价 了 呢 小本生意 请亲 谅解\n",
      "\n",
      "我 一不小心 就 拍 了 一组 我 在 拍 一组 可以 嘛 <eos> 那 就 等 你们 处理 喽\t好 的 亲退 了\n",
      "\n",
      "那好 的 就 拍 这款 <eos> 颜色 有 这种 <eos> 这个 不是 叫 红色 吗 <eos> 这个 不要 <eos> 俩 和 一 是 一体 的 <eos> 那 我 不 喜欢\t颜色 的话 一般 茶刀 茶针 和 二合一 的话 都 是 红木 檀 和 黑木 檀 哦\n",
      "\n",
      "不是 免 运费\t本店 茶具 订单 满 99 包邮除 宁夏 青海 内蒙古 海南 新疆 西藏 满 39 包邮\n",
      "\n"
     ]
    }
   ],
   "source": [
    "readline('data/multi_train.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据预处理\n",
    "\n",
    "- 过滤问题或回答长度太大的对话\n",
    "- 过滤含有频数低于阈值的词汇的会话\n",
    "- 对过滤后的高质量对话进行编码\n",
    "- 对编码后的对话数据集进行填充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建词汇编码与反编码表\n",
    "\n",
    "- 创建一个Vov类，包含各类编码表的功能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.724440Z",
     "start_time": "2019-03-31T12:22:29.711514Z"
    }
   },
   "outputs": [],
   "source": [
    "# 创建一个voc类，用来从给定数据中构建编码表和反编码表,注意voc的实例一开始就需创建，为所有训练/测试数据共用，因而只能有一个\n",
    "class Voc:\n",
    "    \n",
    "    def __init__(self, voc_params):\n",
    "        # 编码表基本信息\n",
    "        self.name = voc_params.name                  # voc实例的名称\n",
    "        self.file_dir = voc_params.file_dir          # 创建voc的数据的位置\n",
    "        self.vocab_dir = voc_params.vocab_dir        # 创建voc的频数表的位置\n",
    "        self.save_dir = voc_params.save_dir          # voc的保存位置\n",
    "        self.trim = voc_params.trim                  # 是否修剪稀有词汇\n",
    "        self.PAD_token = voc_params.PAD_token        # 填充标记\n",
    "        self.SOS_token = voc_params.SOS_token        # 句子开头标记\n",
    "        self.EOS_token = voc_params.EOS_token        # 句子结尾标记\n",
    "        self.min_count = voc_params.min_count        # 过滤稀有词汇的阈值\n",
    "        \n",
    "        # 编码表内容\n",
    "        self.word2idx = {\"<pad>\": self.PAD_token, \"<sos>\": self.SOS_token, \"<eos>\": self.EOS_token}\n",
    "        self.word2count = {}\n",
    "        self.indx2word = {self.PAD_token: \"<pad>\", self.SOS_token: \"<sos>\", self.EOS_token: \"<eos>\"}\n",
    "        self.num_words = 3   # 编码表所含词汇数,初始时也就是<pad>,<sos>,<eos>三个\n",
    "        \n",
    "        # 构建Voc实例\n",
    "        self.bulidVoc()\n",
    "        \n",
    "    # 将句子拆分后加入编码和反编码表                 \n",
    "    def addSentence(self, sentence):\n",
    "        for word in sentence:\n",
    "            self.addWord(word)\n",
    "            \n",
    "    # 将词汇加入编码和反编码表\n",
    "    def addWord(self, word):\n",
    "        if word not in self.word2count:\n",
    "            self.word2idx[word] = self.num_words\n",
    "            self.word2count[word] = 1\n",
    "            self.indx2word[self.num_words] = word\n",
    "            self.num_words += 1\n",
    "        else:\n",
    "            self.word2count[word] += 1\n",
    "            \n",
    "    # 将句子转换为编码后的序列\n",
    "    def sentence2sequence(self, sentence):\n",
    "        return [self.word2idx[word] for word in sentence]\n",
    "    \n",
    "    # 将编码的序列反编码为句子\n",
    "    def sequence2sentence(self, sequence):\n",
    "        return [self.indx2word[indx] for indx in sequence]\n",
    "    \n",
    "    # 构建Voc\n",
    "    def bulidVoc(self):\n",
    "        vacab = torch.load(self.vocab_dir)\n",
    "        with open(self.file_dir, 'r', encoding='utf-8') as f:\n",
    "            for dialog in f:\n",
    "                context, target = dialog.strip().split('\\t')\n",
    "                context = context.split()\n",
    "                target = target.split()\n",
    "                context_len = len(context)\n",
    "                target_len = len(target)\n",
    "                # 过滤含有稀有词的对话\n",
    "                if not self.trim or (not self.RareWords(context, vacab) and not self.RareWords(target, vacab)):\n",
    "                    self.addSentence(context)\n",
    "                    self.addSentence(target)\n",
    "        # 保存voc\n",
    "        torch.save(self.__dict__, self.save_dir)\n",
    "\n",
    "    def RareWords(self, sentence, vocab):\n",
    "        \"\"\"\n",
    "        判断该句子中是否含有频数过低的词汇\n",
    "        输入:\n",
    "            sentence:给定句子\n",
    "            vocab:给定的词汇频数表\n",
    "        输出：\n",
    "            True or False\n",
    "        \"\"\"\n",
    "        for word in sentence:\n",
    "            if vocab[word] < self.min_count and word != '<eos>':   # 由于context中问题之间的分割符为\"<eos>\"\n",
    "                return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.737460Z",
     "start_time": "2019-03-31T12:22:29.725438Z"
    }
   },
   "outputs": [],
   "source": [
    "# 为每个数据集创建一个数据类\n",
    "class MyDataset(Dataset):\n",
    "    \n",
    "    def __init__(self, dataset_params, voc):\n",
    "        # 基本信息\n",
    "        self.name = dataset_params.name\n",
    "        self.voc = voc\n",
    "        self.file_dir = dataset_params.file_dir                          # 原始数据位置\n",
    "        self.max_context_len = dataset_params.max_context_len            # 上下文长度阈值\n",
    "        self.max_target_len = dataset_params.max_target_len              # 目标长度阈值\n",
    "        \n",
    "        # 初始化数据集的内容\n",
    "        self.contexts = []\n",
    "        self.targets = []\n",
    "        self.contexts_lens = []\n",
    "        self.targets_lens = []\n",
    "        self.dialog_num = 0\n",
    "        \n",
    "        # 加载数据\n",
    "        self.loadData()\n",
    "        \n",
    "    def loadData(self):\n",
    "        with open(self.file_dir, 'r', encoding='utf-8') as f:\n",
    "            for dialog in f:\n",
    "                context, target = dialog.strip().split('\\t')\n",
    "                context = context.split()\n",
    "                target = target.split()\n",
    "                context_len = len(context)\n",
    "                target_len = len(target)\n",
    "                # 丢弃长度不合适的对话\n",
    "                if 0 < context_len <= self.max_context_len and 0 < target_len <= self.max_target_len:\n",
    "                    # 丢弃含有voc字典中没有收录的词汇的对话，此即说明对话含有稀有词\n",
    "                    if not self.has_unknow_word(context) and not self.has_unknow_word(target):\n",
    "                        # 编码后加入数据列表\n",
    "                        self.contexts.append(torch.LongTensor([self.voc.SOS_token] + self.voc.sentence2sequence(context) + [self.voc.EOS_token]))\n",
    "                        self.targets.append(torch.LongTensor([self.voc.SOS_token] + self.voc.sentence2sequence(target) + [self.voc.EOS_token]))\n",
    "                        self.contexts_lens.append(context_len + 2)\n",
    "                        self.targets_lens.append(target_len + 2)\n",
    "                        self.dialog_num += 1\n",
    "        \n",
    "    def has_unknow_word(self, sentence):\n",
    "        for word in sentence:\n",
    "            if word not in self.voc.word2idx:\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    # 该方法可使数据集通过切片的形式获得第idx个样本\n",
    "    def __getitem__(self, idx):\n",
    "        sample = {'context': self.contexts[idx], 'target': self.targets[idx],\n",
    "                 'context_len': self.contexts_lens[idx], 'target_len': self.targets_lens[idx]}\n",
    "        return sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seq2Seq模型\n",
    "\n",
    "模型包含：\n",
    "\n",
    "- 编码器架构\n",
    "- 注意力权重计算方式\n",
    "- 解码器结构\n",
    "- 训练方法\n",
    "- 使用Beam Search 对输入的单句话生成和搜索最优回答"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "总体架构：\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "图片来源：https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1553790594467&di=57b521eda3ec02835c0bb4b93baf2f62&imgtype=0&src=http%3A%2F%2Fimage.mamicode.com%2Finfo%2F201805%2F20180526131546738401.png"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "全局注意力计算方式：\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "图片来源：https://www.cnblogs.com/databingo/p/9769928.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编码器计算图：\n",
    "\n",
    "- 将单词索引转换为词嵌入 embeddings\n",
    "- 将批次输入序列进行填充\n",
    "- 为RNN模块压缩已填充批次序列，注意此处需要将序列按长度从大到小排序\n",
    "- 通过GRU进行前向传播\n",
    "- 解压批次序列\n",
    "- 对双向GRU输出求和\n",
    "- 返回输出和最终隐藏状态"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "解码器计算图：\n",
    "\n",
    "- 获取当前输入的词嵌入\n",
    "- 通过一层dropout层(可选)\n",
    "- 通过单向GRU进行前向传播(仅向前一个时间步,所以每个样本的长度都为1，就不需要填充压缩了)\n",
    "- 通过当前GRU的输出和编码器的输出按上图计算注意力权重及后续计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练方法：\n",
    "\n",
    "- 先对输入序列和目标序列进行一定处理\n",
    "- 将输入序列通过编码器向前传播计算\n",
    "- 初始化解码器后每次一时间步地通过解码器向前传播计算\n",
    "- 每次将解码器的输出和目标输出序列进行计算得到当前损失并累加(注意，本次处理中目标序列的填充部分不进行损失的计算)\n",
    "- 输出损失"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集束搜索步骤：\n",
    "\n",
    "- 先类似训练步骤通过编码器和解码器进行向前传播计算\n",
    "- 候选列表为同一时刻只有beam_size个元素的list，每个元素也为一个长度为三的list，第一个为当前得分(softmax的log累加分数),第二个为选择的输出序列，第三个为当前隐藏状态张量\n",
    "- 每次分别使用list的各元素计算下一时间步的beam_size个最优方案，得到beam_size * beam_size个方案，再从中选择最优的三个\n",
    "- 迭代直至设置长度\n",
    "- 在候选列表中选择得分最高的输出序列并返回"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要特别注意计算过程中的度数为1的维数，其易通过某些函数而别消除。本训练每次都按照批数量作为第一个维度，所以要特别注意输入为单样本的情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.775305Z",
     "start_time": "2019-03-31T12:22:29.739402Z"
    }
   },
   "outputs": [],
   "source": [
    "class Seq2SeqModel(nn.Module):\n",
    "    \n",
    "    def __init__(self, voc, model_params):\n",
    "        super(Seq2SeqModel, self).__init__()\n",
    "        \n",
    "        self.name = model_params.name\n",
    "        \n",
    "        # 共用架构\n",
    "            ## embedding层\n",
    "        self.num_embeddings = voc.num_words                      # 嵌入字典的大小,也即所用voc编码表的大小\n",
    "        self.embedding_dim  = model_params.embedding_dim         # 每个嵌入向量的大小 \n",
    "        self.embedding = nn.Embedding(self.num_embeddings, self.embedding_dim)     # 初始化embedding，后续可能会被加载训练过的embedding参数\n",
    "        self.hidden_size = model_params.hidden_size              # gru的隐藏状态向量的大小，编码器和解码器\n",
    "        self.beam_size = model_params.beam_size                  # 集束宽\n",
    "        self.use_bidirectional = model_params.use_bidirectional  # 编码器是否使用双向GRU\n",
    "        self.voc = voc                                           # 模型的词嵌入初始化和解码器初始化信息依赖于所给的voc\n",
    "        \n",
    "        # 编码器架构\n",
    "            ## gru层\n",
    "        self.encoder_num_layers = model_params.encoder_num_layers # 编码器GRU层数\n",
    "        self.encoder_dropout = model_params.encoder_dropout       # 编码器除最外一层外每层后增加的dropout层的丢失概率\n",
    "        self.encoder_gru = nn.GRU(self.embedding_dim, self.hidden_size, self.encoder_num_layers,\n",
    "                                 batch_first=True, dropout=(self.encoder_dropout if self.encoder_num_layers > 1 else 0),\n",
    "                                 bidirectional=model_params.use_bidirectional)\n",
    "        \n",
    "        \n",
    "        # 解码器架构\n",
    "            ## embedding层后加一层dropout\n",
    "        self.decoder_dropout = model_params.decoder_dropout\n",
    "        self.embedding_dropout = nn.Dropout(self.decoder_dropout)  # 解码器除最外一层外每层后增加的dropout层的丢失概率\n",
    "            ## gru层\n",
    "        self.max_target_len = model_params.max_target_len          # 生成的回答的最大长度\n",
    "        self.decoder_num_layers = model_params.decoder_num_layers  # 解码器GRU层数\n",
    "        self.decoder_gru = nn.GRU(self.embedding_dim, self.hidden_size, self.decoder_num_layers,\n",
    "                                 batch_first=True, dropout=(self.decoder_dropout if self.decoder_num_layers > 1 else 0),\n",
    "                                 )\n",
    "            ## 结合全局注意力的最终输出层\n",
    "        self.concat = nn.Linear(self.hidden_size * 2, self.hidden_size)\n",
    "        self.out = nn.Linear(self.hidden_size, self.num_embeddings)\n",
    "    \n",
    "    # 模型架构\n",
    "    \n",
    "        ## 编码器\n",
    "    def EncoderRNN(self,context_batch, context_batch_lens, h_0=None):\n",
    "        \"\"\"\n",
    "        将一个批次的输入序列通过Encoder架构\n",
    "        输入：\n",
    "            context_batch:一个批次的输入序列,其长度已由大到小排序.shape=[context1, context2,...];context1.size=torch.size(num1)\n",
    "            context_batch_lens:该批次输入序列的长度，已从小到大排序.shape=[num1,num2,...];num1 >= num2 >=...\n",
    "            h_0:gur层的初始隐藏状态，不提供则默认是零.torch.size(encoder_num_layers * encoder_num_directions, batch_size, hidden_size)\n",
    "        输出：\n",
    "            output:编码器GUR网络所有时间步的最后一层输出.torch.size(batch_size, num1, hidden_size)\n",
    "            h_n:编码器GRU网络的最终隐藏状态张量.torch.size(encoder_num_layers * encoder_num_directions, batch_size, hidden_size)\n",
    "        \"\"\"\n",
    "        # 填充序列\n",
    "        padded = pad_sequence(context_batch, batch_first=True)    # torch.size(batch_size,num1)\n",
    "        \n",
    "        # 将变量移至给定设备\n",
    "        padded = padded.to(device)\n",
    "        context_batch_lens = torch.LongTensor(context_batch_lens).to(device)\n",
    "        \n",
    "        # embedding\n",
    "        embedded = self.embedding(padded)                                # torch.size(batch_size,num1,embedding_dim)\n",
    "        # 压缩序列\n",
    "        packed = pack_padded_sequence(embedded, context_batch_lens, batch_first=True)\n",
    "        # 将压缩序列通过编码器gru\n",
    "        output, h_n = self.encoder_gru(packed,h_0)\n",
    "        # 解压缩,output中已经有了原序列长度信息，不需再传入\n",
    "        output, _ = pad_packed_sequence(output, batch_first=True)          # torch.size(batch_size,num1,encoder_num_directions * hidden_size)\n",
    "        # 将两个方向的输出相加\n",
    "        output = output[:, :, :self.hidden_size] + output[:, :, self.hidden_size:]\n",
    "        \n",
    "        return output, h_n\n",
    "    \n",
    "        ## 注意力权重\n",
    "    def Atten(self, encoder_output, decoder_output):\n",
    "        \"\"\"\n",
    "        计算当前时刻全局注意力权重\n",
    "        输入：\n",
    "            encoder_output:编码器所有时间步的最后一层输出.torch.size(batch_size, seq_len, hidden_size)\n",
    "            decoder_output:当前时间步解码器GRU的最后一层输出.torch.size(batch_size, 1, hidden_size)\n",
    "        输出：\n",
    "            attn_weights:当前时间步的注意力权重.torch.size(batch_size,seq_len,1)\n",
    "        \"\"\"\n",
    "        # 计算得分\n",
    "        attn_energies = torch.sum(encoder_output * decoder_output, dim=2)           # torch.size(batch_size,seq_len)\n",
    "        # 归一化\n",
    "        attn_weights = F.softmax(attn_energies, dim=1).unsqueeze(2)   # torch.size(batch_size,seq_len,1)\n",
    "        \n",
    "        return attn_weights\n",
    "    \n",
    "    \n",
    "        ## 带注意力计算的解码器\n",
    "    def AttenDecoderRNN(self, decoder_input, last_hidden, encoder_output):\n",
    "        \"\"\"\n",
    "        计算当前时间步解码器的输出\n",
    "        输入：\n",
    "            decoder_input:当前解码器GRU的输入.torch.size(batch_size)\n",
    "            last_hidden:上一个时间步的隐藏状态张量.torch.size(decoder_num_layers,batch_size,hidden_size)\n",
    "            encoder_output:编码器所有时间步的最后一层输出.torch.size(batch_size,seq_len,hidden_size)\n",
    "        输出：\n",
    "            out:当前时间步的预测输出(softmax分数形式).torch.size(batch_size,num_embeddings)\n",
    "            hidden:当前时间步解码器GRU的隐藏状态张量.torch.size(decoder_num_layers,batch_size,hidden_size)\n",
    "        \"\"\"\n",
    "        # 将变量移至给定设备\n",
    "        decoder_input = decoder_input.to(device)\n",
    "        \n",
    "        # embedding\n",
    "        embedded = self.embedding(decoder_input).unsqueeze(1)         # torch.size(batch_size,1,embedding_dim)\n",
    "        # dropout\n",
    "        embedded_dropout = self.embedding_dropout(embedded)\n",
    "        # 通过解码器gru向前计算\n",
    "        decoder_output, hidden = self.decoder_gru(embedded_dropout, last_hidden)  # torch.size(batch_size,1,hidden_size),torch.size(ecoder_num_layers,batch_size,hidden_size)\n",
    "        # 计算注意力权重\n",
    "        attn_weights = self.Atten(encoder_output, decoder_output)    # torch.size(batch_size,seq_len,1)\n",
    "        # 计算带注意力权重的上下文张量和\n",
    "        context = torch.sum(attn_weights * encoder_output, dim=1)                 # torch.size(batch_size,hidden_size)\n",
    "        # 计算最终输出层\n",
    "        concat_input = torch.cat((decoder_output.squeeze(1), context), 1)         # torch.size(batch_size,hidden_size*2)\n",
    "        concat_output = self.concat(concat_input).tanh()                          # torch.size(batch_size,hidden_size)\n",
    "        output = self.out(concat_output)                                          # torch.size(batch_size,num_embeddings)\n",
    "        # 归一化\n",
    "        output = F.softmax(output, dim=1)\n",
    "        return output, hidden\n",
    "    \n",
    "    # 训练\n",
    "    \n",
    "        ## 损失计算辅助函数\n",
    "    @staticmethod\n",
    "    def maskNLLLoss(output, target, mask):\n",
    "        \"\"\"\n",
    "        计算当前时间步该批次输出的mask损失\n",
    "        输入:\n",
    "            output:当前时间步模型最终输出.torch.size(batch_size,num_embeddings)\n",
    "            target:当前时间步目标输出.torch.size(batch_size)\n",
    "            mask:当前时间步目标输出的掩码.torch.size(batch_size)\n",
    "        输出:\n",
    "            loss:当前时间步批次样本的平均损失，已忽略目标输出为<pad>的损失.\n",
    "            n_Total:当前时间步批次样本目标输出的实际词汇数.\n",
    "        \"\"\"\n",
    "        # 当前时间步目标输出实际的词汇数\n",
    "        n_Total = mask.sum()\n",
    "        # 计算交叉熵,由于target并未使用one-hot编码，所有需要自行计算交叉熵\n",
    "        crossEntropy = -torch.log(torch.gather(output, 1, target.unsqueeze(1)))\n",
    "        # 丢弃target中<pad>对应位置产生的交叉熵\n",
    "        loss = torch.masked_select(crossEntropy, mask).mean()\n",
    "        loss = loss.to(device)\n",
    "        \n",
    "        return loss, n_Total.item()\n",
    "        \n",
    "    \n",
    "        ## 训练方法\n",
    "    def forward(self, context_batch, context_batch_lens, target_batche, optimizer, Train_Params):\n",
    "        \"\"\"\n",
    "        执行训练\n",
    "        输入：\n",
    "            context_batch:该批次的输入序列,其长度已由大到小排序.shape=[context1, context2,...];context1.size=torch.size(num1)\n",
    "            context_batch_lens:该批次输入序列的长度，已从小到大排序.shape=[num1,num2,...];num1 >= num2 >=...\n",
    "            target_batche:该批次目标输出序列.shape=[target1,target2,...];target1.size=torch.size(x)\n",
    "            optimizer:优化器\n",
    "            Train_Params:训练参数实例.\n",
    "        输出：\n",
    "            loss_mean:该批次平均加权损失(权数为各时间步目标输出的实际词汇数)\n",
    "        \"\"\"\n",
    "        # 提取参数\n",
    "        teacher_forcing_ratio = Train_Params.teacher_forcing_ratio\n",
    "        clip = Train_Params.clip\n",
    "        \n",
    "        # 填充目标输出序列并计算其mask\n",
    "        target_batche = pad_sequence(target_batche, batch_first=True)\n",
    "        mask = torch.ByteTensor(target_batche >0)\n",
    "        \n",
    "        # 梯度清零\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # 将变量移至给定设备\n",
    "        target_batche = target_batche.to(device)\n",
    "        mask = mask.to(device)\n",
    "        \n",
    "        # 初始化变量\n",
    "        loss = 0\n",
    "        print_loss = []\n",
    "        n_totals = 0\n",
    "        \n",
    "        # 通过编码器向前传播计算\n",
    "        encoder_output, encoder_hidden = self.EncoderRNN(context_batch, context_batch_lens)\n",
    "        \n",
    "        # 将句子开头的编码作为初始化解码器输入\n",
    "        decoder_input = torch.LongTensor([self.voc.SOS_token for _ in range(len(target_batche))])\n",
    "        \n",
    "        \n",
    "        # 将解码器的最终隐藏状态张量作为编码器的初始隐藏状态张量\n",
    "        decoder_hidden = encoder_hidden[:self.decoder_num_layers]\n",
    "        \n",
    "        # 决定时间步是否使用teacher forcing技巧\n",
    "        use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n",
    "        \n",
    "        # 解码器向前传播计算，每次一个时间步\n",
    "        for t in range(self.max_target_len):\n",
    "            # 若当前时间步大于该批次目标序列的最大长度，则退出。因为超出部分也不计算损失\n",
    "            if t >= target_batche.size(1):\n",
    "                break\n",
    "                \n",
    "            decoder_output, decoder_hidden = self.AttenDecoderRNN(decoder_input, decoder_hidden, encoder_output)\n",
    "            # 计算当前时间步损失\n",
    "            mask_loss, n_Total = self.maskNLLLoss(decoder_output, target_batche[:,t], mask[:,t])\n",
    "            loss += mask_loss\n",
    "            print_loss.append(mask_loss.item() * n_Total)\n",
    "            n_totals += n_Total\n",
    "            \n",
    "            if use_teacher_forcing:\n",
    "                # 此时下一时间步的输入为当前时间步的目标输出\n",
    "                decoder_input = target_batche[:,t]\n",
    "                \n",
    "            else:\n",
    "                # 此时下一时间步的输入使用当前时间步的预测输出\n",
    "                decoder_input = torch.argmax(decoder_output, dim=1)\n",
    "                \n",
    "        # 反向传播\n",
    "        loss.backward()\n",
    "        \n",
    "        # 梯度修剪\n",
    "        _ = nn.utils.clip_grad_norm_(self.parameters(), clip)\n",
    "        \n",
    "        # 参数更新\n",
    "        optimizer.step()\n",
    "        \n",
    "        # 加权损失\n",
    "        loss_mean = sum(print_loss) / n_totals\n",
    "        \n",
    "        return loss_mean\n",
    "        \n",
    "    \n",
    "    # 评估\n",
    "    \n",
    "        ## 评估搜索辅助函数\n",
    "    def BeamSearch(self, encoder_output, Beam, beam_size):\n",
    "        \"\"\"\n",
    "        给定之前时间步选择的token及上一隐藏状态和分数计算当前时间步分数最高的三个输出.\n",
    "        输入:\n",
    "            encoder_output:编码器所有时间步的最后一层输出.torch.size(1,seq_len,hidden_size)\n",
    "            embedding:词嵌入类实例.\n",
    "            Beam:[scores, tokens, hidden],其中\n",
    "                score是输出为前t-1时间步输出为tokens的累加对数softmax分数.torch.size(1)\n",
    "                hidden,为上一时间步的隐藏状态.torch.size(decoder_num_layers,1,hidden_size)\n",
    "                tokens,前t-1时间步的输出.torch.size(1, t-1)\n",
    "            beam_size:集束宽.\n",
    "        输出：\n",
    "            Beam:含有输出分数最高的beam_size个beam的list.\n",
    "        \"\"\"\n",
    "        scores, tokens, hidden = Beam\n",
    "        decoder_input = tokens[:, -1]\n",
    "        \n",
    "        scores = scores.to(device)\n",
    "        tokens = tokens.to(device)\n",
    "        \n",
    "        Beam = []\n",
    "        \n",
    "        # 给定输入token(t-1)和hidden，计算当前时间步的解码器输出\n",
    "        decoder_output, hidden = self.AttenDecoderRNN(decoder_input, hidden, encoder_output)\n",
    "        \n",
    "        # 选择softmax分数最高的beam_size项\n",
    "        score, token = torch.topk(torch.log(decoder_output), beam_size, dim=1)\n",
    "        \n",
    "        for b in range(beam_size):\n",
    "            # 累加对数softmax分数\n",
    "                        \n",
    "            beam = [score[:,b] + scores, torch.cat((tokens, token[:,b].unsqueeze(1)), 1), hidden]\n",
    "            Beam.append(beam)\n",
    "        \n",
    "        return Beam\n",
    "        \n",
    "    \n",
    "    def BeamSearchIters(self, context, context_len):\n",
    "        \"\"\"\n",
    "        使用集束搜索算法选取概率最大的回答\n",
    "        输入：\n",
    "            context:输入序列.[torch.size(num1)]\n",
    "            context_lens:输入序列的长度，[num1]\n",
    "            embedding:词嵌入类实例.\n",
    "        输出：\n",
    "            token_top:分数最高的一个输出序列.torch.size(1, max_target_len)\n",
    "        \"\"\"\n",
    "        # 获取参数\n",
    "        beam_size = self.beam_size             # 集束宽.当beam_size=1时即变成了贪婪搜索算法\n",
    "        \n",
    "        # 通过编码器\n",
    "        encoder_output, encoder_hidden = self.EncoderRNN(context, context_len)\n",
    "        # 初始化解码器\n",
    "        decoder_hidden = encoder_hidden[:self.decoder_num_layers]\n",
    "        decoder_input = torch.LongTensor([self.voc.SOS_token]).unsqueeze(0)\n",
    "        \n",
    "        # 初始化\n",
    "        beam = [torch.zeros(1), decoder_input, decoder_hidden]\n",
    "        Beam = []\n",
    "        for _ in range(beam_size):\n",
    "            Beam.append(beam)\n",
    "        \n",
    "        # 通过解码器迭代，一次输出bean_size个最可能的词汇\n",
    "        for t in range(self.max_target_len):\n",
    "            Beam_t = []\n",
    "            for b in range(beam_size):\n",
    "                Beam_t = Beam_t + self.BeamSearch(encoder_output, Beam[b], beam_size)\n",
    "            \n",
    "            # 在得到的beam_size * beam_size个元素中选取分数最大的前beam_size个\n",
    "            Beam = sorted(Beam_t, key=lambda x: -x[0])[:beam_size]\n",
    "        \n",
    "        \n",
    "        # 获取分数最大的beam\n",
    "        beam_top = max(Beam, key=lambda x: x[0])\n",
    "        \n",
    "        scores_top, tokens_top, _ = beam_top\n",
    "        \n",
    "        return tokens_top"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 迭代训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:24:04.670645Z",
     "start_time": "2019-03-31T12:24:04.656682Z"
    }
   },
   "outputs": [],
   "source": [
    "def trainIters(train_params, dataset, model, optimizer, start_iteration=None):\n",
    "    \"\"\"\n",
    "    迭代训练\n",
    "    输入：\n",
    "        train_params:训练参数\n",
    "        model.model_name:模型名称.\n",
    "        model.voc:此次训练的model用的voc实例.注意其与dataset用的voc需一致.\n",
    "        dataset:此次训练采用的数据集.为nn.DataSet的子类实例.可使用切片和索引取出相应位置的可直接训练的规范格式样本.\n",
    "        dataset.name:训练数据的名称.\n",
    "        dataset.dialog_num:训练数据的样本数.\n",
    "        model:采用的模型.其为nn.Module的子类实例，可调用实现编码器、解码器向前传播计算及向后传播计算返回损失.\n",
    "        optimizer:优化器.\n",
    "        train_params.save_dir:此次训练的各超参数、参数、损失值等的保存位置.\n",
    "        train_params.n_iteration:该次训练的迭代次数\n",
    "        train_params.batch_size:每批次样本量.\n",
    "        train_params.print_every:每print_every次迭代就打印出其平均损失.\n",
    "        train_params.save_every:每save_evety次迭代就保存训练的各类数据.\n",
    "        start_iteration:本次迭代训练从第几次迭代开始，适用于从中断的训练继续的情况.\n",
    "    输出：\n",
    "        \n",
    "    \"\"\"\n",
    "    # 提取参数\n",
    "    model_name = model.name\n",
    "    voc = model.voc\n",
    "    \n",
    "    corpus_name = dataset.name\n",
    "    dialog_num = dataset.dialog_num\n",
    "    \n",
    "    n_iteration = train_params.n_iteration\n",
    "    save_dir = train_params.save_dir\n",
    "    print_every = train_params.print_every\n",
    "    save_every = train_params.save_every\n",
    "    batch_size = train_params.batch_size\n",
    "    \n",
    "    \n",
    "    print(\"初始化\")\n",
    "    print_loss = []\n",
    "        \n",
    "    # 若是从之前的中断处继续训练，则迭代次数应该在其基础上累加\n",
    "    start_iteration = start_iteration + 1 if start_iteration else 1\n",
    "    \n",
    "    \n",
    "    \n",
    "    print(\"开始训练\")\n",
    "    for iteration in range(start_iteration, start_iteration + n_iteration):\n",
    "        # 每次迭代重新生成打乱的数据索引迭代器\n",
    "        batch_indx_loader = DataLoader(torch.arange(dialog_num), batch_size=batch_size, shuffle=True)\n",
    "        for batch_indx in batch_indx_loader:\n",
    "            # 由于后续编码器计算中pack_paded_sequence函数的要求，需根据将输入的context按长度从小到大排序\n",
    "            sorted_indx = np.argsort([dataset[idx]['context_len'] for idx in batch_indx])[::-1]\n",
    "            sorted_indx = [batch_indx[idx] for idx in sorted_indx]\n",
    "            \n",
    "            # 获取该批次索引对应排序后的数据            \n",
    "            context_batch = [dataset[idx]['context'] for idx in sorted_indx]\n",
    "            context_batch_lens = [dataset[idx]['context_len'] for idx in sorted_indx]\n",
    "            target_batche = [dataset[idx]['target'] for idx in sorted_indx]\n",
    "            \n",
    "            # 训练\n",
    "            loss = model(context_batch, context_batch_lens, target_batche, optimizer, train_params)\n",
    "            \n",
    "            print_loss.append(loss)\n",
    "            \n",
    "        print_loss = np.average(print_loss)\n",
    "        \n",
    "        \n",
    "        # 打印进度\n",
    "        if (iteration - start_iteration) % print_every == 0:\n",
    "            # 计算这期间的平均损失\n",
    "            print_loss_avg = print_loss / print_every\n",
    "            print(\"已迭代次数：{}; 完成进度: {:.1f}%; 近几次迭代的平均损失: {:.4f}\".format(iteration - start_iteration +1,\n",
    "                                                                      (iteration - start_iteration +1)/n_iteration * 100,\n",
    "                                                                       print_loss_avg))\n",
    "            print_loss = []\n",
    "        \n",
    "        # 保存当前进度\n",
    "        if (iteration - start_iteration) % save_every == 0:\n",
    "            directory = os.path.join(save_dir, model_name, corpus_name, '{}-{}_{}'.format(model.encoder_num_layers, model.decoder_num_layers, model.hidden_size))\n",
    "            if not os.path.exists(directory):\n",
    "                os.makedirs(directory)\n",
    "            # 保存\n",
    "            torch.save({\n",
    "                'iteration': iteration,\n",
    "                'model': model.state_dict(),\n",
    "                'optimizer': optimizer.state_dict(),\n",
    "                'loss': loss,\n",
    "                'voc_dict': voc.__dict__,\n",
    "                'embedding': model.embedding.state_dict()\n",
    "            }, os.path.join(directory, '{}_{}_{:.3f}.tar'.format(iteration, 'checkpoint', print_loss_avg)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估文本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.803266Z",
     "start_time": "2019-03-31T12:22:29.792261Z"
    }
   },
   "outputs": [],
   "source": [
    "class EvaluateInput(object):\n",
    "    \"\"\"\n",
    "    接受从键盘端输入的多个问题，处理并通过模型计算生成合适的回答\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, model, voc, max_context_len):\n",
    "        self.model = model\n",
    "        self.voc = voc\n",
    "        self.max_context_len = max_context_len\n",
    "        self.context = []\n",
    "        self.length = [0]\n",
    "        self.r = \"[0-9\\s+\\.\\!\\/_,$%^*()?;；:-【】+\\\"\\']+|[+——！，;:。？、~@#￥%……&*（）]+\"  # 需去除的标点符号\n",
    "    \n",
    "    def preprocess(self, sentence):\n",
    "        \"\"\"\n",
    "        对输入的问题进行处理\n",
    "        输入：\n",
    "            sentence:键盘端的原始输入\n",
    "        输出：\n",
    "            context:多个问题合并的标准化输出\n",
    "            length:长度\n",
    "        \"\"\"\n",
    "        # 去除标点符号及空格\n",
    "        sentence = re.sub(self.r, \"\", sentence)\n",
    "        # 分词\n",
    "        sentence = jieba.lcut(sentence)\n",
    "        # 编码\n",
    "        sentence = self.voc.sentence2sequence(sentence)\n",
    "        # 将当前输入句子与前几轮的输入(若有的话)合并\n",
    "        self.context = self.context + sentence + [voc.EOS_token]\n",
    "        # 若context过长，则删除context中最早的一个问题\n",
    "        while len(self.context) > self.max_context_len:\n",
    "            idx = self.context.index(voc.EOS_token)\n",
    "            self.context = self.context[idx+1:]\n",
    "            \n",
    "    def evaluate(self):\n",
    "        \"\"\"\n",
    "        使用给定模型生成合适的回复.\n",
    "        输入：\n",
    "            context:上下文向量.list,len=1.\n",
    "            length:句子长度.list.len=1\n",
    "        \"\"\"\n",
    "        length = [len(self.context)]\n",
    "        context = [torch.LongTensor(self.context)]\n",
    "        \n",
    "        tokens_top = self.model.BeamSearchIters(context, length)\n",
    "        # tokens解码\n",
    "        answer = self.voc.sequence2sentence(tokens_top.cpu().squeeze().numpy().tolist())\n",
    "\n",
    "        return answer\n",
    "    \n",
    "    def Input(self):\n",
    "        \"\"\"\n",
    "        对话接口\n",
    "        \"\"\"\n",
    "        while True:\n",
    "            \n",
    "            try:\n",
    "                # 获取输入的句子\n",
    "                input_sentence = input('亲，请输入您的问题哦：')\n",
    "                # 检查使用者是否要退出对话\n",
    "                if input_sentence == 'q' or input_sentence == 'quit':\n",
    "                    # 清空并退出\n",
    "                    self.context = []\n",
    "                    self.length = [0]\n",
    "                    break\n",
    "                # 预处理问题\n",
    "                self.preprocess(input_sentence)\n",
    "                # 生成回答\n",
    "                answer = self.evaluate()\n",
    "                # 格式化并打印出句子\n",
    "                output_sentence = [word for word in answer if word not in ['<pad>', '<eos>', '<sos>']]\n",
    "                print('人工智障客服：',' '.join(output_sentence))\n",
    "            except KeyError:\n",
    "                print(\"对不起，您输入的句子含有敏感/未知词，请重新输入。\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 配置默认参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Voc参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.811211Z",
     "start_time": "2019-03-31T12:22:29.804226Z"
    }
   },
   "outputs": [],
   "source": [
    "class Voc_Params():\n",
    "    \n",
    "    def __init__(self):\n",
    "        # 设置默认参数\n",
    "        self.name = 'voc_params'                        # voc实例的名称\n",
    "        self.file_dir = 'data/multi_train.txt'          # 创建voc的数据的位置\n",
    "        self.vocab_dir = 'data/vocab.txt'               # 创建voc的频数表的位置\n",
    "        self.save_dir = 'data/voc.txt'                  # voc的保存位置\n",
    "        self.trim = True              # 是否修剪稀有词汇\n",
    "        self.PAD_token = 0            # 填充标记\n",
    "        self.SOS_token = 1            # 句子开头标记\n",
    "        self.EOS_token = 2           # 句子结尾标记\n",
    "        self.min_count = 5           # 过滤稀有词汇的阈值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.821182Z",
     "start_time": "2019-03-31T12:22:29.812207Z"
    }
   },
   "outputs": [],
   "source": [
    "class Dataset_Params():\n",
    "    \n",
    "    def __init__(self):\n",
    "        # 设置默认参数\n",
    "        self.name = 'dataset'                       # 数据集名称\n",
    "        self.voc = voc                              # 对数据集进行处理的voc实例\n",
    "        self.file_dir = 'data/multi_train.txt'      # 原始数据位置\n",
    "        self.max_context_len = 60                   # 上下文长度阈值\n",
    "        self.max_target_len = 30                    # 目标长度阈值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.829162Z",
     "start_time": "2019-03-31T12:22:29.822179Z"
    }
   },
   "outputs": [],
   "source": [
    "class Model_Params(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        # 设置默认参数\n",
    "        self.name = 'seq2seq_model'            # 模型名称\n",
    "        self.embedding_dim = 100        # 每个嵌入向量的大小 \n",
    "        self.hidden_size = 50          # gru的隐藏状态向量的大小，编码器和解码器\n",
    "        self.beam_size = 10             # 集束宽\n",
    "        self.encoder_num_layers = 1    # 编码器GRU层数\n",
    "        self.decoder_num_layers = 2    # 解码器GRU层数\n",
    "        self.encoder_dropout = 0.5     # 编码器除最外一层外每层后增加的dropout层的丢失概率\n",
    "        self.decoder_dropout = 0.5     # 解码器除最外一层外每层后增加的dropout层的丢失概率\n",
    "        self.use_bidirectional = True  # 编码器是否使用双向GRU\n",
    "        self.max_target_len = 30       # 生成的回答的最大长度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 开始训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从上次中断处继续训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:29.836179Z",
     "start_time": "2019-03-31T12:22:29.830159Z"
    }
   },
   "outputs": [],
   "source": [
    "loadFilename = 'model/118_checkpoint_1.740.tar'  # 上次训练的进度文件保存位置\n",
    "checkpoint_iter = 118 # 上次训练最后保存文件的的迭代次数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:22:52.311162Z",
     "start_time": "2019-03-31T12:22:50.660579Z"
    }
   },
   "outputs": [],
   "source": [
    "# 若有\n",
    "if loadFilename:\n",
    "\n",
    "    # 继续在本机上训练\n",
    "    checkpoint = torch.load(loadFilename)\n",
    "    # 若需要切换到cpu上训练\n",
    "    # checkpoint = torch.load(loadFilename, map_location=torch.device('cpu'))\n",
    "    model_sd = checkpoint['model']\n",
    "    optimizer_sd = checkpoint['optimizer']\n",
    "    embedding_sd = checkpoint['embedding']\n",
    "    voc_dict = checkpoint['voc_dict']\n",
    "    start_iteration = checkpoint['iteration'] + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建各实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:23.154848Z",
     "start_time": "2019-03-31T12:23:13.136903Z"
    }
   },
   "outputs": [],
   "source": [
    "# 修改参数\n",
    "#\n",
    "#\n",
    "voc_params = Voc_Params()\n",
    "\n",
    "voc = Voc(voc_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:23.163972Z",
     "start_time": "2019-03-31T12:23:23.156843Z"
    }
   },
   "outputs": [],
   "source": [
    "# 加载voc参数\n",
    "\n",
    "if loadFilename:\n",
    "    voc.__dict__ = voc_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:33.546699Z",
     "start_time": "2019-03-31T12:23:23.165818Z"
    }
   },
   "outputs": [],
   "source": [
    "# 修改参数\n",
    "# \n",
    "#\n",
    "\n",
    "dataset_params = Dataset_Params()\n",
    "\n",
    "dataset = MyDataset(dataset_params, voc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:33.600813Z",
     "start_time": "2019-03-31T12:23:33.549612Z"
    }
   },
   "outputs": [],
   "source": [
    "# 修改参数\n",
    "#\n",
    "#\n",
    "\n",
    "model_params = Model_Params()\n",
    "\n",
    "model = Seq2SeqModel(voc, model_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:33.811030Z",
     "start_time": "2019-03-31T12:23:33.603467Z"
    }
   },
   "outputs": [],
   "source": [
    "# 加载模型参数\n",
    "\n",
    "if loadFilename:\n",
    "    model.load_state_dict(model_sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:35.996244Z",
     "start_time": "2019-03-31T12:23:33.812030Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Seq2SeqModel(\n",
       "  (embedding): Embedding(26591, 100)\n",
       "  (encoder_gru): GRU(100, 50, batch_first=True, bidirectional=True)\n",
       "  (embedding_dropout): Dropout(p=0.5)\n",
       "  (decoder_gru): GRU(100, 50, num_layers=2, batch_first=True, dropout=0.5)\n",
       "  (concat): Linear(in_features=100, out_features=50, bias=True)\n",
       "  (out): Linear(in_features=50, out_features=26591, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 执行训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.002171Z",
     "start_time": "2019-03-31T12:23:35.997183Z"
    }
   },
   "outputs": [],
   "source": [
    "# 训练参数\n",
    "class Train_Params(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        # 设置默认值\n",
    "        self.clip = 10                     # 梯度修剪阈值\n",
    "        self.teacher_forcing_ratio = 0.5  # 每一时间步的编码器使用tearch_forcing的概率\n",
    "        self.learning_rate = 0.01         # 学习率\n",
    "        self.n_iteration = 1              # 迭代次数\n",
    "        self.save_dir = 'model'                # 训练进度保存位置\n",
    "        self.print_every = 1             # 打印进度的迭代间隔\n",
    "        self.save_every = 1               # 保存训练进度的迭代间隔\n",
    "        self.batch_size = 256             # 批大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.010150Z",
     "start_time": "2019-03-31T12:23:36.003167Z"
    }
   },
   "outputs": [],
   "source": [
    "train_params = Train_Params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.019123Z",
     "start_time": "2019-03-31T12:23:36.012144Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Seq2SeqModel(\n",
       "  (embedding): Embedding(26591, 100)\n",
       "  (encoder_gru): GRU(100, 50, batch_first=True, bidirectional=True)\n",
       "  (embedding_dropout): Dropout(p=0.5)\n",
       "  (decoder_gru): GRU(100, 50, num_layers=2, batch_first=True, dropout=0.5)\n",
       "  (concat): Linear(in_features=100, out_features=50, bias=True)\n",
       "  (out): Linear(in_features=50, out_features=26591, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 训练模式\n",
    "model.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.029096Z",
     "start_time": "2019-03-31T12:23:36.020122Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化优化器..\n"
     ]
    }
   ],
   "source": [
    "print(\"初始化优化器..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.035082Z",
     "start_time": "2019-03-31T12:23:36.030095Z"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=train_params.learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.049073Z",
     "start_time": "2019-03-31T12:23:36.037104Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "加载优化器进度..\n"
     ]
    }
   ],
   "source": [
    "print(\"加载优化器进度..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.064003Z",
     "start_time": "2019-03-31T12:23:36.050041Z"
    }
   },
   "outputs": [],
   "source": [
    "# 加载进度\n",
    "if loadFilename:\n",
    "    optimizer.load_state_dict(optimizer_sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:23:36.068995Z",
     "start_time": "2019-03-31T12:23:36.065002Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练...\n"
     ]
    }
   ],
   "source": [
    "print(\"开始训练...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:36:47.754669Z",
     "start_time": "2019-03-31T12:24:07.478011Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化\n",
      "开始训练\n",
      "已迭代次数：1; 完成进度: 100.0%; 近几次迭代的平均损失: 1.7485\n"
     ]
    }
   ],
   "source": [
    "trainIters(train_params, dataset, model, optimizer, start_iteration=checkpoint_iter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 运行评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:36:47.778606Z",
     "start_time": "2019-03-31T12:36:47.765637Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Seq2SeqModel(\n",
       "  (embedding): Embedding(26591, 100)\n",
       "  (encoder_gru): GRU(100, 50, batch_first=True, bidirectional=True)\n",
       "  (embedding_dropout): Dropout(p=0.5)\n",
       "  (decoder_gru): GRU(100, 50, num_layers=2, batch_first=True, dropout=0.5)\n",
       "  (concat): Linear(in_features=100, out_features=50, bias=True)\n",
       "  (out): Linear(in_features=50, out_features=26591, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估模式\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:36:47.786582Z",
     "start_time": "2019-03-31T12:36:47.781597Z"
    }
   },
   "outputs": [],
   "source": [
    "# 创建评估实例\n",
    "evaluateInput = EvaluateInput(model, voc, max_context_len=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-31T12:51:57.329526Z",
     "start_time": "2019-03-31T12:51:54.856047Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "亲，请输入您的问题哦：quit\n"
     ]
    }
   ],
   "source": [
    "# 开始聊天\n",
    "evaluateInput.Input()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
